package com.example.springbooteasycode.zjrc.project.Koal.test;

import com.example.springbooteasycode.zjrc.project.Koal.AAAstructure.ErrorCodes;

import java.io.IOException;
import java.net.Socket;
import java.util.Arrays;

public class HsmProcJava {
    // 模拟向系统日志写十六进制内容的方法，实际可根据需求对接真实日志系统
    public static void writeHEXSysLog(int logType, byte[] data, String prefix) {
        StringBuilder sb = new StringBuilder(prefix);
        for (byte b : data) {
            sb.append(String.format("%02X ", b));
        }
        System.out.println(sb.toString());
    }

    // 模拟发送/接收报文的函数，对应C代码中的HsmProc
    public static int hsmProc(int nSocket, int nDataInLen, int nBufOutLen,
                              byte[] szDataIn, byte[] szDataOut) {
        // 模拟发送数据到加密机（这里简单打印示意，实际需用Socket发送）
        writeHEXSysLog(0, szDataIn, "#####SEND: ");

        int nRes = 0;
        int datlen;
        int totalSent = 0;
        // 模拟发送数据循环，实际应通过Socket的OutputStream发送
        while (totalSent < nDataInLen) {
            // 这里只是模拟，实际要处理真实的Socket发送逻辑
            datlen = nDataInLen - totalSent;
            totalSent += datlen;
            if (datlen <= 0) {
                return ErrorCodes.ERR_CMD_SEND;
            }
        }
        if (totalSent != nDataInLen) {
            return ErrorCodes.ERR_CMD_SEND;
        }

        // 模拟接收数据，这里用已知的返回报文构造字节数组示意
        String responseStr = "00136AB7FFFFFFFFFFFFFFFF00967B94B28102C9CA";
        byte[] responseBytes = hexStringToByteArray(responseStr);
        // 简单校验，实际应从Socket的InputStream读取
        if (responseBytes.length > nBufOutLen) {
            return ErrorCodes.ERR_RES_DATA;
        }
        System.arraycopy(responseBytes, 0, szDataOut, 0, responseBytes.length);
        nRes = responseBytes.length;

        // 模拟处理接收后的逻辑，类似C代码中处理读取长度等
        if (nRes < 2) {
            return ErrorCodes.ERR_RES_DATA;
        }
        int len = ((szDataOut[0] & 0xFF) << 8) | (szDataOut[1] & 0xFF) + 2;
        if (nRes < len) {
            return ErrorCodes.ERR_RES_DATA;
        }

        writeHEXSysLog(0, Arrays.copyOf(szDataOut, nRes), "#####RECV: ");

        return ErrorCodes.ERR_RES_NONE;
    }

    // 将十六进制字符串转为字节数组，用于处理返回报文等
    public static byte[] hexStringToByteArray(String hex) {
        int len = hex.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
                    + Character.digit(hex.charAt(i + 1), 16));
        }
        return data;
    }

    public static void main(String[] args) {
        try {
            // 模拟Socket连接，实际需替换为真实的IP和端口去建立连接
            Socket socket = new Socket("127.0.0.1", 8888);
            int nSocket = socket.getPort(); // 这里只是示意，实际用socket对象操作

            // 构造模拟的输入数据字节数组，这里简单填充，实际按业务构造
            byte[] szDataIn = "YOUR_INPUT_DATA".getBytes();
            int nDataInLen = szDataIn.length;
            int nBufOutLen = 1024; // 假设输出缓冲区大小
            byte[] szDataOut = new byte[nBufOutLen];

            int result = hsmProc(nSocket, nDataInLen, nBufOutLen, szDataIn, szDataOut);
            System.out.println("执行结果错误码: " + result);
            if (result == ErrorCodes.ERR_RES_NONE) {
                System.out.println("执行成功");
            } else {
                System.out.println("执行失败，错误码对应含义可查看ErrorCodes类");
            }

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
